package com.jrauto.CarAppBackend.controller;

/**
 * @author : huiMing
 * Date : 2025年09月03日 15:39
 * @version V1.0
 */
import com.alibaba.fastjson.JSONObject;
import com.jrauto.CarAppBackend.entity.ChatMedia;
import com.jrauto.CarAppBackend.entity.ChatMessage;
import com.jrauto.CarAppBackend.entity.ChatSession;
import com.jrauto.CarAppBackend.entity.User;
import com.jrauto.CarAppBackend.mapper.ChatSessionMapper;
import com.jrauto.CarAppBackend.service.IChatService;
import com.jrauto.CarAppBackend.service.UserService;
import com.jrauto.CarAppBackend.utils.ChatWebSocketHandler;
import jakarta.annotation.Resource;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.List;
import java.util.UUID;


@RestController
@RequestMapping("/chat")
public class ChatController {
    @Resource
    private UserService userService; // 注入用户业务服务
    @Resource
    private IChatService chatService;

    // 注入 ChatSessionMapper，用于通过会话ID查询目标用户
    @Resource
    private ChatSessionMapper chatSessionMapper;

    // 注入 WebSocket 处理器实例，用于实时推送消息
    @Resource
    private ChatWebSocketHandler chatWebSocketHandler;


    // 假设这里通过 Spring Security 或其他方式获取当前登录用户ID
//    private Integer getCurrentUserId() {
//        // TODO: 在实际项目中，应从 Spring Security 的上下文或 JWT 中获取用户ID
//        return 1; // 示例用户ID
//    }


    /**
     * 获取当前认证用户的ID
     * @return 用户ID
     * @throws RuntimeException 如果用户未认证或无法获取用户ID
     */
    private Integer getCurrentUserId() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated() || authentication.getPrincipal() instanceof String) {
            throw new RuntimeException("用户未认证或认证信息无效");
        }
        Object principal = authentication.getPrincipal();
        if (principal instanceof UserDetails) {
            String identifier = ((UserDetails) principal).getUsername(); // 获取 CustomUserDetailsService 返回的用户名 (手机号或openid)

            // ⭐️ 关键修改：使用新的 findUserByIdentifier 方法来查找用户 ⭐️
            User user = userService.findUserByIdentifier(identifier);

            if (user != null) {
                return user.getId();
            }
        }
        throw new RuntimeException("无法获取当前用户ID");
    }


    /**
     * 获取用户会话列表
     * GET /api/chat/sessions
     * @return 会话列表
     */
    @GetMapping("/sessions")
    public List<ChatSession> getSessions() {
        Integer userId = getCurrentUserId();
        return chatService.getSessionsByUserId(userId);
    }

    /**
     * 获取会话聊天记录
     * GET /api/chat/messages/{sessionId}
     * @param sessionId 会话ID
     * @param page 页码
     * @param size 每页数量
     * @return 消息列表
     */
    @GetMapping("/messages/{sessionId}")
    public List<ChatMessage> getMessages(@PathVariable Integer sessionId,
                                         @RequestParam(defaultValue = "1") int page,
                                         @RequestParam(defaultValue = "20") int size) {
        return chatService.getMessagesBySessionId(sessionId, page, size);
    }

    /**
     * 发送一条消息
     * POST /api/chat/send
     * @param message 消息对象
     * @return 发送成功的消息对象
     */
    @PostMapping("/send")
    public ChatMessage sendMessage(@RequestBody ChatMessage message) {
        // 填充消息发送者ID和时间
        message.setSenderId(getCurrentUserId());
        message.setCreatedAt(LocalDateTime.ofInstant(new Date().toInstant(), ZoneId.systemDefault()));

        // 调用服务层处理消息，包括入库和会话更新
        ChatMessage savedMessage = chatService.sendMessage(message);

        // 获取目标用户ID，这里需要根据业务逻辑获取，例如从会话表中查询
//        Integer targetUserId = 2; // 示例：假设目标用户ID为2

        // 通过 sessionId 从会话表中查询目标用户ID
        ChatSession session = chatSessionMapper.selectById(message.getSessionId());

        if (session != null) {
            // 获取目标用户ID，并排除发送者自己
            Integer targetUserId = (session.getUserId().equals(message.getSenderId())) ?
                    session.getTargetId() : session.getUserId();

            // 通过 WebSocket 实时推送消息给接收者
            chatWebSocketHandler.sendMessageToUser(targetUserId, savedMessage.getContent());
        }
        return savedMessage;
    }

    /**
     * 删除一个会话
     * DELETE /api/chat/sessions/{sessionId}
     * @param sessionId 会话ID
     * @return 是否删除成功
     */
    @DeleteMapping("/sessions/{sessionId}")
    public boolean deleteSession(@PathVariable Integer sessionId) {
        Integer userId = getCurrentUserId();
        return chatService.deleteSession(userId, sessionId);
    }

    /**
     * 模拟文件上传接口
     * 实际应用中，这里会处理文件，并将其上传到对象存储服务（如阿里云OSS、MinIO）
     * POST /api/chat/media/upload
     * @param file 上传的文件
     * @param mediaType 媒体类型
     * @return 包含媒体ID和URL的JSON对象
     */
    @PostMapping("/media/upload")
    public JSONObject uploadMedia(@RequestParam("file") MultipartFile file,
                                  @RequestParam("mediaType") Integer mediaType) {
        // TODO: 这里应实现文件上传到对象存储服务的逻辑
        // 示例中，我们仅模拟生成一个URL
        String fileUrl = "https://example.com/media/" + UUID.randomUUID().toString() + ".jpg"; // 假设是图片

        ChatMedia media = new ChatMedia();
        media.setMediaType(mediaType);
        media.setUrl(fileUrl);
        media.setSize((int) file.getSize());
        media.setDuration(0); // 假设是图片或文件，没有时长

        // 保存媒体信息到数据库
        chatService.saveMedia(media);

        JSONObject result = new JSONObject();
        result.put("mediaId", media.getId());
        result.put("url", media.getUrl());
        return result;
    }
}
